package controller

import (
	"AiBus/dao"
	"AiBus/global"
	"AiBus/model"
	"AiBus/request"
	"AiBus/service"
	"AiBus/utils"
	"encoding/json"
	"fmt"
	"github.com/gin-gonic/gin"
	"reflect"
)

/*测试接口*/
func APITest(c *gin.Context) {
	utils.Success(c, 0, "Success")
}

// @Summary AI问答
// @Success 200 {string} string json{"code","message"}
// @Param Authorization	header string true "Bearer xxxxxx"
// @Param data body request.ArgumentsReq{} true "ai问答参数"
// @Router /api/completions [post]
// @version 1.0
func Completions(c *gin.Context) {
	req := request.ArgumentsReq{}
	err := c.ShouldBindJSON(&req)
	UserID := c.GetString("open_id")
	if err != nil {
		utils.Fail(c, 5000, "请输入必传字段")
		return
	}
	service.Completions(c, req, UserID)
}

// @Summary 微信登录
// @Success 200 {string} string json{"code","message"}
// @Param data body request.WXLogin{} true "微信登录请求参数"
// @Router /api/wx_login [post]
// @version 1.0
func WX_Login(c *gin.Context) {
	req := request.WXLogin{}
	if err := c.ShouldBindJSON(&req); err != nil {
		utils.Fail(c, 400, err.Error())
	} else {
		service.Wx_Login(c, req)
	}
}

// @Summary 获取短信验证码
// @Success 200 {string} string json{"code","message"}
// @Router /api/sm_cod [get]
// @version 1.0
func GainSMCode(c *gin.Context) {
	req := request.GainSmCodeReq{}
	if err := c.ShouldBindQuery(&req); err != nil {
		utils.Fail(c, 405, err.Error())
	} else {
		err := utils.SendSMCode(req.Mobile)
		if err != nil {
			global.App.Log.Error(err.Error())
			utils.Fail(c, 405, err.Error())
		} else {
			utils.Success(c, 0, "验证码发送成功")
		}
	}
}

// @Summary 用户信息
// @Param Authorization	header string true "Bearer xxxxxx"
// @Success 200 {string} string json{"code","message"}
// @Router /api/userinfo [get]
// @version 1.0
func GetUserInfo(c *gin.Context) {
	// 获取token中的open_id
	OpenID := c.GetString("open_id")
	service.GetUserInfos(c, OpenID)
}

// @Summary 用户短信登录
// @Param data body request.SMCodeReq{} true "用户短信登录请求参数"
// @Success 200 {string} string json{"code","message"}
// @Router /api/app_code_login [POST]
// @version 1.0
func AppCodeLogin(c *gin.Context) {
	/*短信验证码登录*/
	req := request.SMCodeReq{}
	if err := c.ShouldBindJSON(&req); err != nil {
		utils.Fail(c, 405, err.Error())
	} else {
		get, err := utils.Get(req.Mobile)
		if err != nil {
			fmt.Println("redis error: ", err)
			utils.Fail(c, 400, "用户登录失败，账号或密码错误")
		} else {

			if get == req.Code {
				service.SMCode(c, req)
			} else {
				utils.Fail(c, 405, "验证码错误")
			}
		}
	}
}

// @Summary 用户余额
// @Param Authorization	header string true "Bearer xxxxxx"
// @Success 200 {string} string json{"code","message"}
// @Router /api/credit_grants [POST]
// @version 1.0
func CreditGrants(c *gin.Context) {
	service.CheckGrants(c)
	//req := request.GreditGrantsReq{}
	//err := c.ShouldBindJSON(&req)
	//if err != nil {
	//	utils.Fail(c, 400, err.Error())
	//} else {
	//
	//}
}

/*token校验*/
func CheckToken(c *gin.Context) {
	tokenString := c.Request.Header.Get("Authorization")
	_, err := utils.ParseToken(tokenString)
	fmt.Println(err)
	if err != nil {
		utils.Fail(c, 401, "token过期")
	} else {
		utils.Success(c, 0, "token验证成功")
	}
}

/*版本发布于历史*/
func VersionsHistory(c *gin.Context) {
	versionLists := []model.Versions{}
	var Count int64
	tx := global.App.DB.Find(&versionLists).Count(&Count)
	if tx.Error != nil {
		global.App.Log.Error(tx.Error.Error())
		utils.Fail(c, 408, "版本信息加载失败")
	} else {
		utils.Success(c, Count, versionLists)
	}
}

// @Summary AI问答记录查询
// @Success 200 {string} string json{"code","message"}
// @Param Authorization	header string true "Bearer xxxxxx"
// @Param data body request.ArgumentsReq{} true "AI问答记录查询请求参数"
// @Router /api/search [post]
// @version 1.0
func GetSearch(c *gin.Context) {
	var arguments request.ArgumentsResp

	UserID := c.GetString("open_id")
	/*
		1.查询redis中是否存在数据
		2.如果redis中存在数据直接返回
		3.如果redis中数据不存在，则查询mysql数据库，数据库中存在，则在redis中新增该条记录的缓存，并返回给前端用户

	*/
	redis, err := utils.HistoryRedis(UserID)
	if err != nil {
		// redis中不存在，查询MySQL中的数据
		global.App.Log.Error(err.Error())
		history, Count, err := dao.History(UserID)
		if err != nil {
			utils.Fail(c, 407, "暂无数据")
		} else {
			utils.Success(c, Count, history)
		}

	} else {
		// 这里是从redis中查询出来的缓存数据
		tmp := []map[string]interface{}{}
		of := reflect.TypeOf(redis).Kind().String()
		switch of {
		case "map":
			valueOf := reflect.ValueOf(redis).MapKeys()

			for _, item := range valueOf {
				result, _ := global.App.Redis.HGet(UserID, item.String()).Result()
				json.Unmarshal([]byte(result), &arguments)
				tmp = append(tmp, map[string]interface{}{
					"search_name":    item.String(),
					"search_content": arguments.Choices,
				})
			}
		}
		utils.Success(c, 0, tmp)

	}
}
